package com.atguigu.gmall.product.service.impl;

import com.alibaba.fastjson.JSON;
import com.atguigu.gmall.product.mapper.SkuAttrValueMapper;
import com.atguigu.gmall.product.mapper.SkuSaleAttrValueMapper;
import com.atguigu.gmall.product.mapper.SpuSaleAttrMapper;
import com.atguigu.gmall.product.model.*;
import com.atguigu.gmall.product.service.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class SkuManageServiceImpl implements SkuManageService {

    @Autowired
    private SkuInfoService skuInfoService;

    @Autowired
    private SkuImageService skuImageService;

    @Autowired
    private SkuAttrValueService skuAttrValueService;

    @Autowired
    private SkuSaleAttrValueService skuSaleAttrValueService;

    @Autowired
    private SpuSaleAttrService spuSaleAttrService;

    @Autowired
    private SpuImageService spuImageService;

    /**
     * 查询Spu包含所有商品图片列表
     *
     * @param spuId
     * @return
     */
    @Override
    public List<SpuImage> getSpuImageList(Long spuId) {
        LambdaQueryWrapper<SpuImage> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SpuImage::getSpuId, spuId);
        queryWrapper.select(SpuImage::getId, SpuImage::getSpuId, SpuImage::getImgName, SpuImage::getImgUrl);
        return spuImageService.list(queryWrapper);
    }

    /**
     * 查询指定SPU商品包含销售属性列表
     *
     * @param spuId
     * @return
     */
    @Override
    public List<SpuSaleAttr> getSpuSaleAttrList(Long spuId) {
        SpuSaleAttrMapper spuSaleAttrMapper = (SpuSaleAttrMapper) spuSaleAttrService.getBaseMapper();
        return spuSaleAttrMapper.getSpuSaleAttrList(spuId);
    }

    /**
     * 保存商品sku
     *
     * @param skuInfo
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveSkuInfo(SkuInfo skuInfo) {
        //1.将新增SKU页面提交SKU基本信息封装到SkuInfo对象 保存到sku_info表
        skuInfoService.save(skuInfo);
        Long skuId = skuInfo.getId();
        //2.将新增SKU页面选择图片列表封装SkuImage对象集合中 批量保存到sku_image表
        List<SkuImage> skuImageList = skuInfo.getSkuImageList();
        if (!CollectionUtils.isEmpty(skuImageList)) {
            skuImageList.stream().forEach(skuImage -> {
                //2.1 将sku图片跟sku关联
                skuImage.setSkuId(skuId);
            });
            //2.2 批量保存商品图片
            skuImageService.saveBatch(skuImageList);
        }
        //3.将新增SKU页面选择平台属性封装SkuAttrValue对象集合中 批量保存sku_attr_value表
        List<SkuAttrValue> skuAttrValueList = skuInfo.getSkuAttrValueList();
        if (!CollectionUtils.isEmpty(skuAttrValueList)) {
            skuAttrValueList.stream().forEach(skuAttrValue -> {
                //3.1 将平台属性关联到Sku
                skuAttrValue.setSkuId(skuId);
            });
            //3.2 批量保存平台属性列表
            skuAttrValueService.saveBatch(skuAttrValueList);
        }
        //4.将新增SKU页面选择销售属性封装SkuSaleAttrValue对象集合中 批量保存sku_sale_attr_value表
        List<SkuSaleAttrValue> skuSaleAttrValueList = skuInfo.getSkuSaleAttrValueList();
        if (!CollectionUtils.isEmpty(skuSaleAttrValueList)) {
            skuSaleAttrValueList.stream().forEach(skuSaleAttrValue -> {
                //4.1 关联商品SPU
                skuSaleAttrValue.setSpuId(skuInfo.getSpuId());
                //4.2 关联商品SKU
                skuSaleAttrValue.setSkuId(skuId);
            });
            //4.3 批量保存销售属性
            skuSaleAttrValueService.saveBatch(skuSaleAttrValueList);
        }
    }

    /**
     * 分页查询商品sku列表
     *
     * @param infoPage
     * @param category3Id
     * @return
     */
    @Override
    public Page<SkuInfo> getSkuByPage(Page<SkuInfo> infoPage, Long category3Id) {
        LambdaQueryWrapper<SkuInfo> queryWrapper = new LambdaQueryWrapper<>();
        if (category3Id != null) {
            queryWrapper.eq(SkuInfo::getCategory3Id, category3Id);
        }
        queryWrapper.orderByDesc(SkuInfo::getUpdateTime);
        return skuInfoService.page(infoPage, queryWrapper);
    }

    /**
     * 商品SKU上架
     *
     * @param skuId
     * @return
     */
    @Override
    public void onSale(Long skuId) {
        SkuInfo skuInfo = new SkuInfo();
        skuInfo.setId(skuId);
        skuInfo.setIsSale(1);
        skuInfoService.updateById(skuInfo);
    }

    /**
     * 商品SKU下架
     *
     * @param skuId
     * @return
     */
    @Override
    public void cancelSale(Long skuId) {
        //1.创建更新条件对象 update sku_info set is_sale = 0 where id = 24
        LambdaUpdateWrapper<SkuInfo> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(SkuInfo::getIsSale, 0);
        updateWrapper.eq(SkuInfo::getId, skuId);
        //2.执行更新
        skuInfoService.update(updateWrapper);
    }

    /**
     * 根据skuId查询商品信息（包含图片列表）
     *
     * @param skuId
     * @return
     */
    @Override
    public SkuInfo getSkuInfo(Long skuId) {
        //1.先根据ID查询商品对象
        SkuInfo skuInfo = skuInfoService.getById(skuId);
        //2.根据SkuID查询商品图片列表
        if (skuInfo != null) {
            LambdaQueryWrapper<SkuImage> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(SkuImage::getSkuId, skuId);
            List<SkuImage> skuImageList = skuImageService.list(queryWrapper);
            skuInfo.setSkuImageList(skuImageList);
        }
        return skuInfo;
    }

    @Autowired
    private BaseCategoryViewService baseCategoryViewService;
    /**
     * 根据三级分类ID获取分类信息
     * @param category3Id
     * @return
     */
    @Override
    public BaseCategoryView getCategoryView(Long category3Id) {
        return baseCategoryViewService.getById(category3Id);
    }

    /**
     * 根据SkuId查询商品最新价格
     * @param skuId
     * @return
     */
    @Override
    public BigDecimal getskuPrice(Long skuId) {
        LambdaQueryWrapper<SkuInfo> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SkuInfo::getId,skuId);
        queryWrapper.select(SkuInfo::getPrice);
        SkuInfo skuInfo = skuInfoService.getOne(queryWrapper);
        if (skuInfo !=null){
            return skuInfo.getPrice();
        }
        return null;
    }

    /**
     * 根据skuId查询当前SKU商品包含的平台属性列表
     * @param skuId
     * @return
     */
    @Override
    public List<BaseAttrInfo> getAttrList(Long skuId) {
        SkuAttrValueMapper skuAttrValueMapper = (SkuAttrValueMapper) skuAttrValueService.getBaseMapper();
        return skuAttrValueMapper.getAttrList(skuId);
    }

    /**
     * 查询SPU商品所有销售属性,查询指定SKU销售属性选中效果
     * @param skuId
     * @param spuId
     * @return
     */
    @Override
    public List<SpuSaleAttr> getSpuSaleAttrListCheckBySku(Long skuId, Long spuId) {
        SpuSaleAttrMapper spuSaleAttrMapper = (SpuSaleAttrMapper) spuSaleAttrService.getBaseMapper();
        return spuSaleAttrMapper.getSpuSaleAttrListCheckBySku(skuId,spuId);
    }

    /**
     * 在一组SPU商品下，切换不同的SKU字符串
     * @param spuId
     * @return
     */
    @Override
    public String getSkuValueIdsMap(Long spuId) {
        SkuSaleAttrValueMapper skuSaleAttrValueMapper = (SkuSaleAttrValueMapper) skuSaleAttrValueService.getBaseMapper();
        //1.调用动态SQL得到多条销售属性和SKUID对照关系
        List<Map> list = skuSaleAttrValueMapper.getSkuValueIdsMap(spuId);
        //2.遍历List将所有销售属性ID作为jsonKey 商品SKUID作为value
        HashMap<Object, Object> mapResult = new HashMap<>();
        for (Map map:list) {
            Object value_ids = map.get("value_ids");
            Object skuId = map.get("sku_id");
            mapResult.put(value_ids,skuId);
        }
        return JSON.toJSONString(mapResult);

    }
}
